const api = require('api') 

/**
 * 单个参数判断
 * 该方法仅适用于最终对象判断，如果内部嵌套对象，则需递归判断。params可以是字符串或对象，而data则可以是相同类型的对象或数组
 *
 * params：api中既定的参数规则
 * data：实际对应的参数
 */
const actionResult = (params, data) => {
	if (params) {
		if (Object.prototype.toString.call(params) === '[object Object]') {
			const arr = Object.keys(params)
			for (let i = 0; i < arr.length; i++) {
				const key = arr[i]
				if (params[key]) {
					if (Object.prototype.toString.call(params[key]) === '[object Object]') {
						return actionResult(params[key], data && Object.prototype.toString.call(data) === '[object Object]' ? data[key] : undefined)
					} else if (typeof(params[key]) === 'string') {
						if (data && typeof(data) === 'object') {
							const action = (where) => {
								if (where[key] || where[key] === 0 || where[key] === false) {
									// 必要的参数存在
									return ''
								}
								return params[key] + '不存在'
							}
							if (Array.isArray(data)) {
								if (data.length > 0) {
									for (let i = 0; i < data.length; i++) {
										const res = action(data[i])
										if (res) {
											return `第${i + 1}项的` + res
										}
									}
								} else {
									return params[key] + '所在参数数组不存在'
								}
							} else {
								const errstr = action(data)
								if (errstr) {
									return errstr
								}
							}
						} else {
							return params[key] + '不存在'
						}
					}
				}
			}
		} else if (typeof(params) === 'string') {
			if (!data) {
				return params + '不存在'
			}
		}
	}
	return ''
}
	
/**
 * 参数校验。该方法在前端同样存在，用于校验参数
 * @param {Object} group 前端：接口所在的组；后端：云函数云对象的名称
 * @param {Object} name 前端：对应的接口名称；后端：云对象的具体方法名
 * @param {Object} where 默认是对象，表示除了necessary之外的唯一个参数。如果是云对象中有多个参数，则是数组分别表示对应的参数

 * @returns {String} 是否校验通过。通过为false，不通过为错误信息
 */
module.exports = (group, name, where, isApp = false) => {
	const action = (params) => {
		if (params) {
			if (Array.isArray(params)) {
				if (Array.isArray(where) && where.length === params.length) {
					for (let i = 0; i < params.length; i++) {
						var res = actionResult(params[i], where[i])
						if (res) {
							return res
						}
					}
				} else {
					return '参数结构有误'
				}
			} else {
				return actionResult(params, where)
			}
		}
		return ''
	}
	var result = ''
	if (isApp) { // 前端直接验证
		if (api[group]) {
			if (api[group][name]) {
				const {params} = api[group][name]
				result = action(params)
			}
		}
	} else { // 后端有一个特殊情况，就是数据库操作转为了云对象b-fetch
		Object.keys(api).forEach(key1 => {
			if (typeof(api[key1]) === 'object') {
				Object.keys(api[key1]).forEach(key2 => {
					const {type, isLocal, detail, params} = api[key1][key2]
					if (type && type !== 'function' && !isLocal) {
						// 这种数据库操作已经转化为了云对象b-fetch的数据库操作，无法确定group和name，已经无法精确溯源，但是必须遵循b-fetch的请求规则
					}
					if (group === api[key1][key2].name) {
						if (!name || name === detail) {
							if (!result) {
								result = action(params)
							}
						}
					}
				})
			}
		})
	}
	return result
}